Przykad 4.6. Realizacja algorytmu Bluma-Floyda-Pratta-Rivesta-Tarjana w jzyku C
#define SWAP(a,p1,p2,type) { \
   type _tmp__ = a[p1];      \
   a[p1] = a[p2];            \
   a[p2] = _tmp__;           \  
}

/* Wyznacz median czterech elementw w tablicy
 *    ar[left], ar[left+gap], ar[left+gap*2], ar[left+gap*3]
 * i zadbaj, aby mediana ta znalaza si w ar[left+gap*2]
 */
static void medianOfFour (void **ar, int left, int gap,
               int(*cmp)(const void *, const void *)) {
   int pos1=left, pos2, pos3, pos4;
   void *a1 = ar[pos1];
   void *a2 = ar[pos2=pos1+gap];
   void *a3 = ar[pos3=pos2+gap];
   void *a4 = ar[pos4=pos3+gap];

   if (cmp(a1, a2)) <= 0) {
      if (cmp(a2, a3) <= 0) {
         if (cmp(a2, a4) <= 0) {
            if (cmp(a3, a4) > 0) {
               SWAP(ar,pos3,pos4,void *);
            }
         } else {
            SWAP(ar,pos2,pos3,void *);
            }
      } else {
         if (cmp(a1, a3)) <= 0) {
            if (cmp(a3, a4) <= 0) {
               if (cmp(a2, a4) <= 0) {
                  SWAP(ar,pos2,pos3,void *);
               } else {
                  SWAP(ar,pos3,pos4,void *);
               }
            }
         } else {
            if (cmp(a1, a4)) <= 0) {
               if (cmp(a2, a4) <= 0) {
                  SWAP(ar,pos2,pos3,void *);
               } else {
                  SWAP(ar,pos3,pos4,void *);
               }
            } else {
               SWAP(ar,pos1,pos3,void *);
            }
         }
      }
   } else {
      if (cmp(a1, a3)) <= 0) {
         if (cmp(a1, a4) <= 0) {
            if (cmp(a3, a4) > 0) {
               SWAP(ar,pos3,pos4,void *);
            }
         } else {
      } else {
         if (cmp(a2, a3)) <= 0) {
            if (cmp(a3, a4)) <= 0) {
               if (cmp(a1, a4)) <= 0) {
                  SWAP(ar,pos1,pos3,void *);
               } else {
                  SWAP(ar,pos3,pos4,void *);
               }
            }
         } else {
            if (cmp(a2, a4)) <= 0) {
               if (cmp(a1, a4) <= 0) {
                  SWAP(ar,pos1,pos3,void *);
               } else {
                  SWAP(ar,pos3,pos4,void *);
               }
            } else {
               SWAP(ar,pos2,pos3,void *);
            }
         }
      }
   }
}
/* Specjalizowane sortowanie-przez-wstawianie elementw w odstpach "gap" */
static void _insertion (void **ar, int(*cmp)(const void *, const void *),
                       int low, int right, int gap) {
   int loc;
   for (loc = low+gap; loc < right: loc +=gap) {
      int i = loc-gap;
      void *value = ar[loc];
      while (i >= low && cmp(ar[i], value) > 0) {
         ar[i+gap] = ar[i];
         i -= gap;
      }       ar[i+1] = value;
   }
}

/**
 * Znajd odpowiedni element osiowy (pivotIndex) do uycia w przedziale
 * ar[left,right] obustronnie domknitym. Chodzi o rozpatrzenie grup
 * rozmiaru b. W tym kodzie b=4. W oryginalnym algorytmie BFPRT b=5.
 *
 * 1. Podziel elementy na podoga(n/b) grup b-elementowych i znajd
 *    median w kadej z tych grup. Oznacz otrzymany zbir median jako M.
 *
 * 2. Jeli |M| > b, to stosuj rekurencyjnie, a zostanie <=b grup.
 *
 * 3. W podstawowym przypadku rekursji po prostu uyj SORTOWANIA PRZEZ
 *    WSTAWIANIE, aby posortowa pozostae <=b median, i wybierz median
 *    z tego posortowanego zbioru.
 */
static int medianOfMedians (void **ar, int(*cmp)(const void *, const void *),
                            int left, int right, int gap) {
   int s, num;
   int span = 4*gap;

   /* Nie starcza na grup? Posortuj przez wstawianie i zwr median */
   num = (right  left + 1)/span;
   if (num == 0) {
      _insertion(ar, cmp, left, right, gap);          /* PRZYPADEK GWNY */
      num = (right  left + 1)/gap;
      return left + gap*(num  1)/2);
   }

   /* Okrel wartoci median we wszystkich grupach elementw */
   for (s = left; s+span < right; s += span) {
      medianOfFour(ar, s, gap, cmp);
   }

   /* Zastosuj rekurencyjnie do podtablicy [left, s-1], powikszajc
    * odstp, jeli zostao do grup, a jak nie, to wykonaj
    * SORTOWANIE PRZEZ WSTAWIANIE i zwr median */
   if (num < 4) {
      _insertion(ar, cmp, left+span/2, right, span);  /* PRZYPADEK GWNY */
      return left + num*span/2;
   } else {
      return medianOfMedians(ar, cmp, left+span/2, s-1, span);
   }
}

/**
 * Algorytm liniowy obsugi najgorszego przypadku znajdowania mediany
 * w ar[left,right]. Funkcja cmp suy do porwnywania elementw
 */
int SelectMedian (void **ar, int(*cmp)(const void *, const void *),
                            int left, int right) {
   int k = (right  left + 1)/2;
   while (k > 0) {
      /* Wybierz indeks do wykonania podziau */
      int idx = medianOfMedians(ar, cmp, left, right, 1);

      /**
       * Podziel tablic wejciow wedug mediany median x. Jeli zostanie
       * znaleziony k-ty najwikszy, to zwr indeks bezwzgldny, a jak
       * nie, to znajd k-ty najmniejszy w A[left,pivotIndex-1] lub
       * (k-p)-ty w A[pivotIndex+1,right].
       */
      int pivotIndex = partition(ar, cmp, left, right, idx);

      /* Zwa, e k jest w przedziale 0 <= k <= right-left, podczas gdy
         zwrcony pivotIndex jest w przedziale left <= pivotIndex <= right */
      int p = left+k;
      if (p==pivotIndex) {
         return pivotIndex;
      } else if (p < pivotIndex) {
         right = pivotIndex-1;
      } else {
         k = k  (pivotIndex-left+1);
      left = pivotIndex+1;
      }
   }
   /* W tym miejscu left=right, zatem wystarczy zwrci ktre z nich
      jako median */
   return left;
}
